/**
 * 自动导入服务
 * 处理文件夹的自动扫描、结构识别及转换
 */
import { NovelStructure, FileHandle } from '../../types/fileSystem.ts';
import { TreeItem, ItemType, Novel, Volume, Chapter } from '../../types/novel.ts';
import { convertToNovelTree } from './importer.ts';

/**
 * 自动识别文件夹结构模式
 * 根据文件夹内容识别合适的导入模式
 */
export enum FolderPattern {
    // 标准模式：文件夹为小说，子文件夹为卷，文本文件为章节
    STANDARD = 'standard',

    // 简单模式：文件夹为小说，文本文件为章节（无卷）
    SIMPLE = 'simple',

    // 单文件模式：单个文本文件作为完整小说
    SINGLE_FILE = 'single_file',

    // 未知模式：无法识别的结构
    UNKNOWN = 'unknown'
}

/**
 * 自动导入结果
 */
export interface AutoImportResult {
    novel: Novel | null;
    pattern: FolderPattern;
    success: boolean;
    error?: string;
}

/**
 * 识别文件夹结构模式
 * @param structure 扫描的文件结构
 * @returns 识别的模式
 */
export function detectFolderPattern(structure: NovelStructure): FolderPattern {
    if (!structure || !structure.rootFolder || !structure.volumes) {
        return FolderPattern.UNKNOWN;
    }

    // 如果有卷和章节，判断为标准模式
    if (structure.volumes.length > 0 &&
        structure.volumes.some(v => v.chapters && v.chapters.length > 0)) {
        return FolderPattern.STANDARD;
    }

    // 如果只有章节，没有卷，判断为简单模式
    if (structure.volumes.length === 1 &&
        structure.volumes[0].chapters &&
        structure.volumes[0].chapters.length > 0 &&
        structure.volumes[0].folder.name === '_default_volume_') {
        return FolderPattern.SIMPLE;
    }

    // 如果只有一个章节文件，判断为单文件模式
    if (structure.volumes.length === 1 &&
        structure.volumes[0].chapters &&
        structure.volumes[0].chapters.length === 1) {
        return FolderPattern.SINGLE_FILE;
    }

    return FolderPattern.UNKNOWN;
}

/**
 * 自动处理文件夹导入
 * @param structure 扫描的文件结构
 * @returns 自动导入结果
 */
export async function autoImportNovelStructure(structure: NovelStructure): Promise<AutoImportResult> {
    try {
        if (!structure || !structure.rootFolder) {
            return {
                novel: null,
                pattern: FolderPattern.UNKNOWN,
                success: false,
                error: '无效的文件结构'
            };
        }

        // 检测文件夹模式
        const pattern = detectFolderPattern(structure);

        // 转换为小说树
        const novel = await convertToNovelTree(structure);

        return {
            novel,
            pattern,
            success: true
        };
    } catch (error) {
        console.error('自动导入失败:', error);
        return {
            novel: null,
            pattern: FolderPattern.UNKNOWN,
            success: false,
            error: error instanceof Error ? error.message : '未知错误'
        };
    }
}

/**
 * 将自动导入的小说转换为文件树结构
 * @param novel 导入的小说
 * @returns 文件树项目
 */
export function convertNovelToFileTree(novel: Novel | null): TreeItem | null {
    if (!novel) return null;

    // 创建根节点
    const rootItem: TreeItem = {
        id: novel.id,
        name: novel.name,
        type: ItemType.NOVEL,
        fileHandle: novel.fileHandle,
        children: []
    };

    // 添加卷
    if (novel.children) {
        novel.children.forEach(volume => {
            const volumeItem: TreeItem = {
                id: volume.id,
                name: volume.name,
                type: ItemType.VOLUME,
                fileHandle: volume.fileHandle,
                children: []
            };

            // 添加章节
            if (volume.children) {
                volume.children.forEach(chapter => {
                    const chapterItem: TreeItem = {
                        id: chapter.id,
                        name: chapter.name,
                        type: ItemType.CHAPTER,
                        fileHandle: chapter.fileHandle,
                        content: chapter.content
                    };

                    volumeItem.children?.push(chapterItem);
                });
            }

            rootItem.children?.push(volumeItem);
        });
    }

    return rootItem;
} 